use std::{
    cmp::Ordering,
    collections::{HashMap, HashSet},
    ops::DerefMut,
    str::LinesAny,
    sync::mpsc,
    thread::{self, Thread},
    time::Duration,
};

use chrono::{DateTime, Local};
use itertools::Itertools;
use lazy_static::lazy_static;
use utils::{
    thread_pool::{self, time_cost, SimplePool},
    CacheCap, ThreadSafePtr,
};

extern crate core;

/// 所有章节入口
mod ep1_array_str;
mod ep2_hash_table;
mod ep_daily;
mod ep_hot100;
mod epn_simple_algorithm_template;
mod rabbitmq;
mod redis;
mod utils;

lazy_static! {
    static ref HASHMAP: HashMap<&'static str, &'static str> = {
        let mut m = HashMap::new();
        m.insert("ok", "shit");
        m.insert("ok1", "shit");
        m.insert("ok2", "shit");
        m
    };
}

// 如何实现一个简单的延迟队列
// 考虑
// 1. 消费是否是阻塞的 - 是，每次消费队列元素必须是同步的
// 2. 投递是否是阻塞的 - 否，投递只要指定了时间间隔，就一定可以异步处理
// 结构：
//
#[test]
pub fn test_sum_of_two_digital() {
    fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
        let mut vec: Vec<i32> = vec![];

        let mut map = HashMap::<i32, usize>::new();
        let mut found = false;
        let mut found = &mut found;
        nums.iter().enumerate().for_each(|(i, &v)| {
            if *found == true {
                return;
            }
            if map.contains_key(&(target-v)){
                
                vec.push(i as i32);
                vec.push(*map.get(&(target-v)).unwrap() as i32);
                *found = true;
            }else{
                map.insert(v, i);
            }
        });
        vec
    }

    // fn two_sum2(nums: Vec<i32>, target: i32) -> Vec<i32> {

    // }

    println!("{:?}", two_sum(vec![2, 7, 15, 11], 9))
}

pub fn main() {}

// pub fn main() {
//     let leaked_msg = {
//         let test_leak = "this is a leak test".to_string();
//         let test_leak_ptr = &test_leak as *const String;
//         let call = || {
//             println!("{}", test_leak);
//             test_leak
//         };
//         call();
//         test_leak_ptr
//     };
//     println!("{}", unsafe { leaked_msg.as_ref().unwrap() });

//     let am = "shit".to_string();
//     let am = ThreadSafePtr::capture(&am);

//     static len: usize = 10_000;

//     time_cost(move || {
//         (0..len)
//             .map(|_| {
//                 thread::spawn(move || {
//                     println!("{}", am);
//                 })
//             })
//             .for_each(|th| {
//                 th.join().unwrap();
//             });
//     });

//     let ch = mpsc::channel();

//     let mut th_pool = thread_pool::SimplePool::new(4);
//     // time_cost(move || {
//     //     (0..len)
//     //         .map(|_| {
//     //             th_pool.commit(move || {
//     //                 println!("{}", am);
//     //             })
//     //         })
//     //         .for_each(|t| t.get());
//     // });

//     // 虽然这个BUG大概马上就能修复（看见PR了）
//     // 但现在还是能用的
//     // pub fn make_static_mut<'a, T>(input: &'a mut T) -> &'static mut T {
//     //     fn helper_mut<'a, T>(_: [&'static &'a (); 0], v: &'a mut T) -> &'static mut T {
//     //         v
//     //     }
//     //     let f: fn([&'static &'static (); 0], &'a mut T) -> &'static mut T = helper_mut;
//     //     f([], input)
//     // }
//     // 可以用纯safe代码无视生命周期复制出一个static周期的可变借用
//     // 去掉全部mut可以得到一个复制不可变借用到&'static借用的
// }
